package main

import "fmt"

func main() {
	// 切片 切片就是一个框，框住了一块连续的内存
	var s []int    // 定义一个存放int类型元素的切片
	var a []string // 定义一个存放string类型的切片
	fmt.Println(s, a)
	fmt.Println(s == nil)
	fmt.Println(a == nil)
	// 初始化
	s = []int{1, 2, 3}
	a = []string{"吗", "hap", "w微213"}
	fmt.Println(s, a)

	// 长度和容量
	fmt.Printf("len(a):%d cap(a):%d\n", len(a), cap(a))
	fmt.Printf("len(s):%d cap(s):%d\n", len(s), cap(s))

	// 由数组到切片
	a1 := [...]int{1, 2, 3, 4, 5, 22, 7, 9}
	a2 := a1[0:4] // 基于一个数组切割，左包含右不包含，《左闭右开)
	fmt.Println(a2)
	a3 := a1[1:2]
	fmt.Println(a3)
	a4 := a1[1:]
	fmt.Println(a4)
	a5 := a1[:4]
	fmt.Println(a5)
	a6 := a1[:4]
	fmt.Println(a6)
	// 切片的容量是指底层数组的容量
	fmt.Printf("len(a5):%d cap(a5):%d\n", len(a5), cap(a5))
	// 切片的容量是指底层数组的容量
	fmt.Printf("len(a6):%d cap(a6):%d\n", len(a6), cap(a6))
	// 切片再切片
	// 切片是引用类型，都指向了底层的一个数组
	a7 := a6[3:]
	fmt.Printf("len(a7):%d cap(a7):%d\n", len(a7), cap(a7))
	a1[6] = 1300 // 修改了底层数组的值
	fmt.Println(a1)

	// make 函数创建切片
	m1 := make([]int, 5, 10) // 标准结构
	fmt.Printf("m1=%v len(m1)=%d cap(m1)=%d\n", m1, len(m1), cap(m1))

	// 切片的赋值
	s3 := []int{1, 3, 5}
	s4 := s3
	fmt.Println(s4)
	s3[0] = 1000
	fmt.Println(s3, s4)
	// 切片的遍历
	for i := 0; i < len(s3); i++ {
		fmt.Println(s3[i])
	}
	for i, i2 := range s3 {
		fmt.Println(i2, i)
	}
	// append
	yy := []string{"背景", "上海", "shen"}
	fmt.Printf("yy=%v len(yy)=%d cap(yy)=%d\n", yy, len(yy), cap(yy))
	//人须用原来的切片变量接收返回值
	ss := []string{"武汉", "000"}
	yy = append(yy, ss...) // ... 表示拆分
	fmt.Println(yy)
	fmt.Printf("yy=%v len(yy)=%d cap(yy)=%d\n", yy, len(yy), cap(yy))

	// copy
	d1 := []int{1, 2, 3, 5}
	var d3 = make([]int, 4, 4)
	d2 := d1
	copy(d3, d2)
	d1[0] = 100
	fmt.Println(d3, d1)

	// 删除元素
	d1 = append(a1[:1], a1[2:]...)
	fmt.Println(d1)
	// 追加
	var y = make([]int, 5, 10)
	for i := 0; i < 10; i++ {
		y = append(y, i)
	}
	fmt.Println(y)
}
